package cz.pecinovsky.česky.oopnz._125_;
//Příliš žluťoučký kůň úpěl ďábelské ódy

import cz.pecinovsky.česky.oopnz._000_.Run;

import cz.pecinovsky.česky.oopnz.správce.Přesouvač;
import cz.pecinovsky.česky.oopnz.správce.SprávcePlátna;


import static cz.pecinovsky.česky.oopnz._125_.Světlo_125_133.Světlo;
import static cz.pecinovsky.česky.oopnz._125_.TestUtility_129_133.TestUtility;


////////////////////////////////////////////////////////////////////////////////
//%%+  +++++ Konec ignorovaného počátečního textu +++++
//%I+ =133c
//
//import správce.*;
//%I-
//%I+ >=133z
//
//import cz.pecinovsky.česky.oopnz.správceplátna.Přesouvač;
//import cz.pecinovsky.česky.oopnz.správceplátna.SprávcePlátna;
//%I-
//%A+ >=133z

import cz.pecinovsky.česky.oopnz.utility.Barva;
import cz.pecinovsky.česky.oopnz.utility.IO;
import cz.pecinovsky.česky.oopnz.utility.Pozice;
//%A-
//%X+ xxxxx Začátek přeskakovaného textu xxxxx
/*******************************************************************************
 *<pre>
 * Předchozí: Není - Toto_je_nově_definovaná_třída
 *
 * Projekt  018z_02_Tvary
 *  + testBlikni()
 *
 * Projekt  019z_11_Správce
 *   ~ Třída převedena do projektu ovládaného správcem plátna
 *</pre>
 */
public class SvětloTest_125_133
{ static
//%X- ----- Konec přeskakovaného textu -----


/*******************************************************************************
 * Testovací třída {@code SvětloTest}  slouží ke komplexnímu otestování
 * třídy {@link SvětloTest}.
 *
 * @author Rudolf PECINOVSKÝ
 * @version 6.03.2017 — 2010-11-08
 */
public class SvětloTest extends junit.framework.TestCase
{
    private SprávcePlátna SP;
    private Světlo světlo0;
    private Světlo světloXY;
    private Světlo světloXYB;
    private Světlo světloXYP;
    private Světlo světloXYPB;
    private Světlo světloXYPBZ;



//== KONSTANTNÍ ATRIBUTY TŘÍDY =================================================
//== PROMĚNNÉ ATRIBUTY TŘÍDY ===================================================
//== STATICKÝ INICIALIZAČNÍ BLOK - STATICKÝ KONSTRUKTOR ========================
//== KONSTANTNÍ ATRIBUTY INSTANCÍ ==============================================
//== PROMĚNNÉ ATRIBUTY INSTANCÍ ================================================
//== PŘÍSTUPOVÉ METODY VLASTNOSTÍ TŘÍDY ========================================
//== OSTATNÍ NESOUKROMÉ METODY TŘÍDY ===========================================

//##############################################################################
//== KONSTRUKTORY A TOVÁRNÍ METODY =============================================

    /***************************************************************************
     * Vytvoří test se zadaným názvem.
     *
     * @param název  Název konstruovaného testu
     */
    public SvětloTest( String název )
    {
        super(název);
    }



//== PŘÍPRAVA A ÚKLID PŘÍPRAVKU ================================================

    /***************************************************************************
     * Inicializace předcházející spuštění každého testu a připravující tzv.
     * přípravek (fixture), což je sada objektů, s nimiž budou testy pracovat.
     */
    @Override
    protected void setUp()
    {
        světlo0    = new Světlo();
        světloXY   = new Světlo( 50,  50);
        světloXYB  = new Světlo(100, 100, Barva.ČERVENÁ);
        světloXYP  = new Světlo(  0, 100, 100);
        světloXYPB = new Světlo(100,   0, 100, Barva.MODRÁ);
        světloXYPBZ= new Světlo(150, 150, 150, Barva.FIALOVÁ, Barva.ŽÁDNÁ);

        SP = SprávcePlátna.getInstance();
        SP.přidej(světlo0);
        SP.přidej(světloXY);
        SP.přidej(světloXYB);
        SP.přidej(světloXYP);
        SP.přidej(světloXYPB);
        SP.přidej(světloXYPBZ);

//%X+ <126
        System.out.println("\n====== Instance v přípravku pro " + this +
                           "\n| SP: " + SP +
                           "\n| světlo0:    " + světlo0 +
                           "\n| světloXY:   " + světloXY +
                           "\n| světloXYB:  " + světloXYB +
                           "\n| světloXYM : " + světloXYP +
                           "\n| světloXYMB: " + světloXYPB +
                           "\n| světloXYMB: " + světloXYPBZ +
                           "\n======");
//%X-
        IO.zpráva("Světla připravena");
    }


    /***************************************************************************
     * Úklid po testu - tato metoda se spustí po vykonání každého testu.
     */
    @Override
    protected void tearDown()
    {
    }


//== SOUKROMÉ A POMOCNÉ METODY TŘÍDY ===========================================
//== SOUKROMÉ A POMOCNÉ METODY INSTANCÍ ========================================
//%I+ <129
//
//    /***************************************************************************
//     * Za pomoci přesouvače plynule prohodí pozice zadaných světel.
//     *
//     * @param s1 První světlo
//     * @param s2 Druhé světlo
//     */
//    private void pomPlynuleProhoďPozice(Světlo s1, Světlo s2)
//    {
//        Přesouvač přesouvač = new Přesouvač(10);
//        Pozice p1 = s1.getPozice();
//        přesouvač.přesunNa(s2.getPozice(), s1);
//        přesouvač.přesunNa(p1,             s2);
//    }
//
//
//    /***************************************************************************
//     * Vyzkouší změny pozice a velikosti zadaného světla.
//     *
//     * @param s Testované světlo
//     */
//    private void pomPoziceVelikost(Světlo s)
//    {
//        final int ms = 500;
//        s.setPozice(0, 150);
//        IO.čekej(ms);
//        s.setModul(150);
//        IO.čekej(ms);
//        s.setModul(25);
//        IO.čekej(ms);
//        SP.odstraň(s);
//        IO.čekej(ms);
//    }
//
//%I-

    /***************************************************************************
     * Prohodí pozice zadaných světel a nechá zkontrolovat,
     * zda si světla své pozice doopravdy vyměnila.
     *
     * @param s1 První světlo
     * @param s2 Druhé světlo
     */
    private void pomProhoďPozice(Světlo s1, Světlo s2)
    {
        final int ms = 1000;

        s1.zhasni();
        s2.zhasni();
        IO.čekej(ms);

        Pozice p1 = s1.getPozice();
        s1.setPozice(s2.getPozice());
        s2.setPozice(p1);

        IO.čekej(ms);
        s1.rozsviť();
        s2.rozsviť();

        IO.čekej(ms);
    }

//%I+ >126 <129
//
//    /***************************************************************************
//     * Prohodí pozice zadaných světel a nechá zkontrolovat,
//     * zda si světla své pozice doopravdy vyměnila.
//     *
//     * @param s1 První světlo
//     * @param s2 Druhý světlo
//     */
//    private void pomProhoďPoziceSKontrolou(Světlo s1, Světlo s2)
//    {
//        Pozice p1 = s1.getPozice();
//        Pozice p2 = s2.getPozice();
//
//        System.out.println("Výchozí: " + p1 + " <--> " + p2);
//        pomProhoďPozice(s1, s2);
//        System.out.println("Cílová:  " + s1.getPozice() +
//                              " <--> " + s2.getPozice() + "\n");
//
//        assertEquals(p1, s2.getPozice());
//        assertEquals(p2, s1.getPozice());
//    }
//
//%I-


//== INTERNÍ DATOVÉ TYPY =======================================================
//== VLASTNÍ TESTY =============================================================
//
//     /***************************************************************************
//      *
//      */
//     public void testXXX()
//     {
//     }


    public void testBlikni()
    {
        světlo0    .zhasni();
        světloXY   .zhasni();
        světloXYB  .zhasni();
        světloXYP  .zhasni();
        světloXYPB .zhasni();
        světloXYPBZ.zhasni();
        IO.čekej(500);
        světlo0    .blikni();
        světloXY   .blikni();
        světloXYB  .blikni();
        světloXYP  .blikni();
        světloXYPB .blikni();
        světloXYPBZ.blikni();
        IO.čekej(500);
        světlo0    .rozsviť();
        světloXY   .rozsviť();
        světloXYB  .rozsviť();
        světloXYP  .rozsviť();
        světloXYPB .rozsviť();
        světloXYPBZ.rozsviť();
    }

//%I+ <129
//
//    public void testPlynuleProhoďPozice()
//    {
//        pomPlynuleProhoďPozice(světlo0,   světloXYPB);
//        pomPlynuleProhoďPozice(světloXYB, světloXYP);
//        pomPlynuleProhoďPozice(světloXYP, světlo0);
//    }
//
//%I-

    public void testPlynuléPosuny()
    {
        Přesouvač p = new Přesouvač(10);
        p.přesunNa(200,   0, světlo0);
        p.přesunNa(200,  50, světloXY);
        p.přesunNa(  0,   0, světloXYPBZ);
        p.přesunNa(200, 100, světloXYPB);
        p.přesunNa(150,   0, světloXYB);
        p.přesunNa(  0, 150, světloXYP);
    }


    public void testPoziceVelikost()
    {
//%I+ <129
//        pomPoziceVelikost(světloXYPBZ);
//        pomPoziceVelikost(světloXYPB);
//        pomPoziceVelikost(světloXYP);
//        pomPoziceVelikost(světloXYB);
//        pomPoziceVelikost(světloXY);
//        pomPoziceVelikost(světlo0);
//%I-
//%X+ <129
        Pozice sem = new Pozice(0, 150);
        int malý   = 25;
        int velký  = 150;

        TestUtility.poziceVelikost(světloXYPBZ, sem, malý, velký);
        TestUtility.poziceVelikost(světloXYPB,  sem, malý, velký);
        TestUtility.poziceVelikost(světloXYP,   sem, malý, velký);
        TestUtility.poziceVelikost(světloXYB,   sem, malý, velký);
        TestUtility.poziceVelikost(světloXY,    sem, malý, velký);
        TestUtility.poziceVelikost(světlo0,     sem, malý, velký);
//%X-
    }


    public void testGetBarva()
    {
        assertEquals(Barva.MODRÁ, světloXYPB.getBarva());
        assertEquals(Barva.MODRÁ, světlo0.getBarva());
    }


    public void testProhoďPozice()
    {
        pomProhoďPozice(světlo0,   světloXYPB);
        pomProhoďPozice(světloXYB, světloXYP);
        pomProhoďPozice(světloXYP, světlo0);
    }
//%X+ <126


    public void testProhoďPoziceSKontrolou()
    {
//%X-
//%I+ >126 <129
//        pomProhoďPoziceSKontrolou(světlo0,   světloXYPB);
//        pomProhoďPoziceSKontrolou(světloXYB, světloXYP);
//        pomProhoďPoziceSKontrolou(světloXYP, světlo0);
//%I-
//%X+ <129
        TestUtility.prohoďPoziceSKontrolou(světlo0,   světloXYPB);
        TestUtility.prohoďPoziceSKontrolou(světloXYB, světloXYP);
        TestUtility.prohoďPoziceSKontrolou(světloXYP, světlo0);
//%X-
//%X+ <126
    }
//%X-
//%X+
     /** */
     public void testPřípravek() {}
//%X-
}
//%%-  ----- Začátek ignorovaného závěrečného textu -----
//%== //Takto se označí řádek, jenž bude odkomentován (vhodné např. pro importy)
//Je-li na 6 pozici mezera, odmaže se také

//== TESTY A METODA MAIN =======================================================
    private SvětloTest_125_133() {}

    /***************************************************************************
     * Třída, jejíž instance má na starosti úklid mezi jednotlivými testy,
     * který není možno zakomponovat do metody {@code tearDown()},
     * dokud nebudou studenti umět programovat.
     */
    private static class TearDown implements Run.ITD
    {
        /** {@inheritDoc} */
        @Override
        public void ukliď()
        {
//            Plátno.smažPlátno();
            SprávcePlátna.getInstance().odstraňVše();
        }
    }


    /***************************************************************************
     * Testovací metoda.
     */
    public static void test()
    {
//        junit.textui.TestRunner.run(suite());
//        junit.textui.TestRunner.run(new Třída("test"));
        Run.tests(SvětloTest.class,
                new TearDown(),
//                "testPřípravek",
//                "testBlikni",
                "testPoziceVelikost",
//                "testPlynuléPosuny",
//                "testProhoďPozice",
                "testProhoďPoziceSKontrolou",
//                "testPlynuleProhoďPozice",
                "");
        System.exit(0);
    }
    /** @param args Parametry příkazového řádku - nepoužívané. */
    public static void main( String[] args )  {  test();  }
}
